
#include <assert.h>
#include <time.h>
#include <SDL/SDL.h>
#include "SDL.h"

const int TAILLE_SPRITE=32;

SDL_Surface *SDL_load_image(const char* filename );
void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y );



void sdljeuInit(sdlJeu *pSdlJeu)
{
	Jeu *pJeu;
	int dimx, dimy;

	pJeu = &(pSdlJeu->jeu);
	jeuInit(pJeu);

	assert(   SDL_Init( SDL_INIT_VIDEO )!= -1 );

	dimx = getDimX( jeuGetCstTerrainPtr(pJeu) );
	dimy = getDimY( jeuGetCstTerrainPtr(pJeu) );
	dimx = dimx * TAILLE_SPRITE;
	dimy = dimy * TAILLE_SPRITE;
	pSdlJeu->surface_ecran = SDL_SetVideoMode(   dimx, dimy, 32, SDL_SWSURFACE );
	assert( pSdlJeu->surface_ecran!=NULL);
	SDL_WM_SetCaption("Infected University 0.1", NULL );

    pSdlJeu->surface_menu = SDL_load_image("data/FondMenu.bmp");
    if (pSdlJeu->surface_menu==NULL)
    pSdlJeu->surface_menu = SDL_load_image("../data/FondMenu.bmp");
    assert( pSdlJeu->surface_menu!=NULL);

    pSdlJeu->surface_menu_fin = SDL_load_image("data/FondMenuPerdu.bmp");
    if (pSdlJeu->surface_menu_fin==NULL)
    pSdlJeu->surface_menu_fin = SDL_load_image("../data/FondPerdu.bmp");
    assert( pSdlJeu->surface_menu_fin!=NULL);

    //bouton
    pSdlJeu->surface_bouton_jouer = SDL_load_image("data/Bouton_Jouer.bmp");
    if (pSdlJeu->surface_bouton_jouer==NULL)
    pSdlJeu->surface_bouton_jouer = SDL_load_image("../data/Bouton_Jouer.bmp");
    assert( pSdlJeu->surface_bouton_jouer!=NULL);

    pSdlJeu->surface_bouton_quitter = SDL_load_image("data/Bouton_Quitter.bmp");
    if (pSdlJeu->surface_bouton_quitter==NULL)
    pSdlJeu->surface_bouton_quitter = SDL_load_image("../data/Bouton_Quitter.bmp");
    assert( pSdlJeu->surface_bouton_quitter!=NULL);

    pSdlJeu->surface_bouton_menu = SDL_load_image("data/Bouton_Menu.bmp");
    if (pSdlJeu->surface_bouton_menu==NULL)
    pSdlJeu->surface_bouton_menu = SDL_load_image("../data/Bouton_Menu.bmp");
    assert( pSdlJeu->surface_bouton_menu!=NULL);

    pSdlJeu->surface_bouton_rejouer = SDL_load_image("data/Bouton_Rejouer.bmp");
    if (pSdlJeu->surface_bouton_rejouer==NULL)
    pSdlJeu->surface_bouton_rejouer = SDL_load_image("../data/Bouton_Rejouer.bmp");
    assert( pSdlJeu->surface_bouton_rejouer!=NULL);

    pSdlJeu->surface_bouton_propos = SDL_load_image("data/Bouton_Apropos.bmp");
    if (pSdlJeu->surface_bouton_propos==NULL)
    pSdlJeu->surface_bouton_propos = SDL_load_image("../data/Bouton_Apropos.bmp");
    assert( pSdlJeu->surface_bouton_propos!=NULL);

    pSdlJeu->surface_bouton_aide = SDL_load_image("data/Bouton_Aide.bmp");
    if (pSdlJeu->surface_bouton_aide==NULL)
    pSdlJeu->surface_bouton_aide = SDL_load_image("../data/Bouton_Aide.bmp");
    assert( pSdlJeu->surface_bouton_aide!=NULL);

	pSdlJeu->surface_Persoversdroite = SDL_load_image("data/persodroite.bmp");
	if (pSdlJeu->surface_Persoversdroite==NULL)
		pSdlJeu->surface_Persoversdroite = SDL_load_image("../data/persodroite.bmp");
	assert( pSdlJeu->surface_Persoversdroite!=NULL);

	pSdlJeu->surface_Persovershaut = SDL_load_image("data/persohaut.bmp");
	if (pSdlJeu->surface_Persovershaut==NULL)
		pSdlJeu->surface_Persovershaut = SDL_load_image("../data/persohaut.bmp");
	assert( pSdlJeu->surface_Persovershaut!=NULL);

	pSdlJeu->surface_Persoversbas = SDL_load_image("data/persobas.bmp");
	if (pSdlJeu->surface_Persovershaut==NULL)
		pSdlJeu->surface_Persoversbas = SDL_load_image("../data/persobas.bmp");
	assert( pSdlJeu->surface_Persoversbas!=NULL);

	pSdlJeu->surface_Persoversgauche = SDL_load_image("data/persogauche.bmp");
	if (pSdlJeu->surface_Persoversgauche==NULL)
		pSdlJeu->surface_Persoversgauche = SDL_load_image("../data/persogauche.bmp");
	assert( pSdlJeu->surface_Persoversgauche!=NULL);

	pSdlJeu->surface_Perso = SDL_load_image("data/perso.bmp");
	if (pSdlJeu->surface_Perso==NULL)
		pSdlJeu->surface_Perso = SDL_load_image("../data/perso.bmp");
	assert( pSdlJeu->surface_Perso!=NULL);

	pSdlJeu->surface_Persodroite = SDL_load_image("data/projectile.bmp");
	if (pSdlJeu->surface_Persodroite==NULL)
		pSdlJeu->surface_Persodroite = SDL_load_image("../data/projectile.bmp");

	pSdlJeu->surface_mur = SDL_load_image("data/mur.bmp");
	if (pSdlJeu->surface_mur==NULL)
		pSdlJeu->surface_mur = SDL_load_image("../data/mur.bmp");
	assert( pSdlJeu->surface_mur!=NULL);

	pSdlJeu->surface_mur2 = SDL_load_image("data/mur2.bmp");
	if (pSdlJeu->surface_mur2==NULL)
		pSdlJeu->surface_mur2 = SDL_load_image("../data/mur2.bmp");

		pSdlJeu->surface_mur3 = SDL_load_image("data/mur3.bmp");
	if (pSdlJeu->surface_mur3==NULL)
		pSdlJeu->surface_mur3 = SDL_load_image("../data/mur3.bmp");

	pSdlJeu->surface_Zombie = SDL_load_image("data/Fantome.bmp");
	if (pSdlJeu->surface_Zombie==NULL)
		pSdlJeu->surface_Zombie = SDL_load_image("../data/Fantome.bmp");
	assert( pSdlJeu->surface_Zombie!=NULL);

	pSdlJeu->surface_Zombiedroite = SDL_load_image("data/Zombiedroite.bmp");
	if (pSdlJeu->surface_Zombiedroite==NULL)
		pSdlJeu->surface_Zombiedroite = SDL_load_image("../data/Zombiedroite.bmp");
	assert( pSdlJeu->surface_Zombiedroite!=NULL);

	pSdlJeu->surface_Zombiebas = SDL_load_image("data/Zombiebas.bmp");
	if (pSdlJeu->surface_Zombiebas==NULL)
		pSdlJeu->surface_Zombiebas = SDL_load_image("../data/Zombiebas.bmp");
	assert( pSdlJeu->surface_Zombiebas!=NULL);

	pSdlJeu->surface_Zombiehaut = SDL_load_image("data/Zombiehaut.bmp");
	if (pSdlJeu->surface_Zombiehaut==NULL)
		pSdlJeu->surface_Zombiehaut = SDL_load_image("../data/Zombiehaut.bmp");
	assert( pSdlJeu->surface_Zombiehaut!=NULL);


	pSdlJeu->surface_Zombie2 = SDL_load_image("data/Zombi1_gauche.bmp");
	if (pSdlJeu->surface_Zombie2==NULL)
		pSdlJeu->surface_Zombie2 = SDL_load_image("../data/Zombi1_gauche.bmp");
	assert( pSdlJeu->surface_Zombie2!=NULL);

	pSdlJeu->surface_Zombie2droite = SDL_load_image("data/Zombi1_droite.bmp");
	if (pSdlJeu->surface_Zombie2droite==NULL)
		pSdlJeu->surface_Zombie2droite = SDL_load_image("../data/Zombi1_droite.bmp");
	assert( pSdlJeu->surface_Zombie2droite!=NULL);

	pSdlJeu->surface_Zombie2bas = SDL_load_image("data/Zombi1_bas.bmp");
	if (pSdlJeu->surface_Zombie2bas==NULL)
		pSdlJeu->surface_Zombie2bas = SDL_load_image("../data/Zombi1_bas.bmp");
	assert( pSdlJeu->surface_Zombie2bas!=NULL);

	pSdlJeu->surface_Zombie2haut = SDL_load_image("data/Zombi1_haut.bmp");
	if (pSdlJeu->surface_Zombie2haut==NULL)
		pSdlJeu->surface_Zombie2haut = SDL_load_image("../data/Zombi1_haut.bmp");
	assert( pSdlJeu->surface_Zombie2haut!=NULL);

	pSdlJeu->surface_Zombie3 = SDL_load_image("data/Zombi2_gauche.bmp");
	if (pSdlJeu->surface_Zombie3==NULL)
		pSdlJeu->surface_Zombie3 = SDL_load_image("../data/Zombi2_gauche.bmp");
	assert( pSdlJeu->surface_Zombie3!=NULL);

	pSdlJeu->surface_Zombie3droite = SDL_load_image("data/Zombi2_droite.bmp");
	if (pSdlJeu->surface_Zombie3droite==NULL)
		pSdlJeu->surface_Zombie3droite = SDL_load_image("../data/Zombi2_droite.bmp");
	assert( pSdlJeu->surface_Zombie3droite!=NULL);

	pSdlJeu->surface_Zombie3bas = SDL_load_image("data/Zombi2_bas.bmp");
	if (pSdlJeu->surface_Zombie3bas==NULL)
		pSdlJeu->surface_Zombie3bas = SDL_load_image("../data/Zombi2_bas.bmp");
	assert( pSdlJeu->surface_Zombie3bas!=NULL);

	pSdlJeu->surface_Zombie3haut = SDL_load_image("data/Zombi2_haut.bmp");
	if (pSdlJeu->surface_Zombie3haut==NULL)
		pSdlJeu->surface_Zombie3haut = SDL_load_image("../data/Zombi2_haut.bmp");
	assert( pSdlJeu->surface_Zombie3haut!=NULL);

	pSdlJeu->surface_Projectile = SDL_load_image("data/projectile.bmp");
	if (pSdlJeu->surface_Projectile==NULL)
		pSdlJeu->surface_Projectile = SDL_load_image("../data/projectile.bmp");

    pSdlJeu->surface_Projectile2 = SDL_load_image("data/projectile2.bmp");
	if (pSdlJeu->surface_Projectile2==NULL)
		pSdlJeu->surface_Projectile2 = SDL_load_image("../data/projectile2.bmp");

    pSdlJeu->surface_Sol = SDL_load_image("data/Sol.bmp");
	if (pSdlJeu->surface_Sol==NULL)
		pSdlJeu->surface_Sol = SDL_load_image("../data/Sol.bmp");
	//assert( pSdlJeu->surface_Projectile>=0);

	pSdlJeu->surface_Zonedemort = SDL_load_image("data/Zonedemort.bmp");
	if (pSdlJeu->surface_Zonedemort==NULL)
		pSdlJeu->surface_Zonedemort = SDL_load_image("../data/Zonedemort.bmp");

    pSdlJeu->surface_Bonus = SDL_load_image("data/Bonus.bmp");
    if (pSdlJeu->surface_Bonus==NULL)
        pSdlJeu->surface_Bonus = SDL_load_image("../data/Bonus.bmp");

}

void sdlmenuAff(sdlJeu *pSdlJeu)
{
int x, y;
x=0;
y=0;
SDL_FillRect( pSdlJeu->surface_ecran, &pSdlJeu->surface_ecran->clip_rect, SDL_MapRGB( pSdlJeu->surface_ecran->format, 0xFF, 0xFF, 0xFF ) );

SDL_apply_surface( pSdlJeu->surface_menu, pSdlJeu->surface_ecran, x, y);
SDL_apply_surface( pSdlJeu->surface_bouton_jouer, pSdlJeu->surface_ecran, 380, 130);
SDL_apply_surface( pSdlJeu->surface_bouton_quitter, pSdlJeu->surface_ecran, 380, 310);
SDL_apply_surface( pSdlJeu->surface_bouton_aide, pSdlJeu->surface_ecran, 380, 180);
SDL_apply_surface( pSdlJeu->surface_bouton_propos, pSdlJeu->surface_ecran, 380, 225);
}
void sdljeuMenu(sdlJeu *pSdlJeu)
{
SDL_Event event;
sdljeuInit( pSdlJeu );
int positionx, positiony, continue_boucle;
continue_boucle = 1;
sdlmenuAff(pSdlJeu);
assert( SDL_Flip( pSdlJeu->surface_ecran )!=-1 );
while (continue_boucle == 1)
{
sdlmenuAff(pSdlJeu);
while ( SDL_PollEvent( &event ) )
{

if ( event.type == SDL_QUIT )
continue_boucle = 0;

if ( event.type == SDL_MOUSEBUTTONDOWN )
{
positionx = event.motion.x;
positiony = event.motion.y;
if ((positionx < 470) && (positionx > 380))
{
if ((163 > positiony) && (positiony > 130) )
{
continue_boucle = 0 ;
sdljeuBoucle(pSdlJeu) ;
}

if ((343 > positiony) && (positiony > 310) )
{
continue_boucle = 0;
exit (EXIT_FAILURE);
}
}
}
}
}
}

void sdlmenufinAff(sdlJeu *pSdlJeu)
{

SDL_FillRect( pSdlJeu->surface_ecran, &pSdlJeu->surface_ecran->clip_rect, SDL_MapRGB( pSdlJeu->surface_ecran->format, 0xFF, 0xFF, 0xFF ) );

SDL_apply_surface( pSdlJeu->surface_menu_fin, pSdlJeu->surface_ecran, 0, 0);
SDL_apply_surface( pSdlJeu->surface_bouton_rejouer, pSdlJeu->surface_ecran, 380, 200);
SDL_apply_surface( pSdlJeu->surface_bouton_quitter, pSdlJeu->surface_ecran, 380, 310);
SDL_apply_surface( pSdlJeu->surface_bouton_menu, pSdlJeu->surface_ecran, 380, 150);

}
void sdljeuMenuFin(sdlJeu *pSdlJeu)
{
    SDL_Event event;
    Jeu * pJeu;
    pJeu = &(pSdlJeu->jeu);
    libereTerrain(pJeu->ter);
    int positionx, positiony, continue_boucle;
    continue_boucle = 1;
    sdlmenufinAff(pSdlJeu);
    assert( SDL_Flip( pSdlJeu->surface_ecran )!=-1 );
    while (continue_boucle == 1)
        {
        sdlmenufinAff(pSdlJeu);
        while ( SDL_PollEvent( &event ) )
        {
            if ( event.type == SDL_QUIT )
            continue_boucle = 0;

if ( event.type == SDL_MOUSEBUTTONDOWN )
{
positionx = event.motion.x;
positiony = event.motion.y;
if ((positionx < 470) && (positionx > 380))
{
if ((343 > positiony) && (positiony > 310) )
{
continue_boucle = 0;
exit (EXIT_FAILURE);
}
if((233 > positiony) && (positiony > 200))
{
continue_boucle = 0 ;
sdljeuInit(pSdlJeu);
sdljeuBoucle(pSdlJeu) ;
}
if((183 > positiony) && (positiony > 150))
{
sdljeuMenu(pSdlJeu);
continue_boucle = 0;
}
}
}
}
}
}


void sdljeuAff(sdlJeu *pSdlJeu)
{
	int x,y,i_Zomb, i_Proj;

    Jeu *Jeu = &(pSdlJeu->jeu);
	const Terrain *Ter = jeuGetCstTerrainPtr(Jeu);
	const Perso *Pers = jeuGetCstPersoPtr(Jeu);
	Bonus * bonus = jeuGetCstBonusPtr(Jeu);

	SDL_FillRect( pSdlJeu->surface_ecran, &pSdlJeu->surface_ecran->clip_rect, SDL_MapRGB( pSdlJeu->surface_ecran->format, 0xFF, 0xFF, 0xFF ) );


	for (x=0;x<getDimX(Ter);x++)
		for (y=0;y<getDimY(Ter);++y)
			if (terrainGetCharCoord(Ter, x, y)=='#')
				SDL_apply_surface(  pSdlJeu->surface_mur2, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);

    for (x=0;x<getDimX(Ter);x++)
		for (y=0;y<getDimY(Ter);++y)
			if (terrainGetCharCoord(Ter, x, y)=='.')
				SDL_apply_surface(  pSdlJeu->surface_Sol, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);

    for (x=0;x<getDimX(Ter);x++)
		for (y=0;y<getDimY(Ter);++y)
			if (terrainGetCharCoord(Ter, x, y)=='*')
				SDL_apply_surface(  pSdlJeu->surface_mur, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);

    for (x=0;x<getDimX(Ter);x++)
		for (y=0;y<getDimY(Ter);++y)
			if (terrainGetCharCoord(Ter, x, y)=='+')
				SDL_apply_surface(  pSdlJeu->surface_mur3, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);

    for (y=0;y<getDimY(Ter);y++)
			if (terrainGetCharCoord(Ter, 0, y)=='~')
				SDL_apply_surface(  pSdlJeu->surface_Zonedemort, pSdlJeu->surface_ecran, 0*TAILLE_SPRITE, y*TAILLE_SPRITE);

    for (i_Zomb=0; i_Zomb<Jeu->nb_Zombie; i_Zomb++)
        {
            char dir;
            dir = getdirectionZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb));

            if (getVieZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb))==1)
            {
                switch (dir)
            {
                case 'd' : SDL_apply_surface(  pSdlJeu->surface_Zombiedroite, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'g': SDL_apply_surface(  pSdlJeu->surface_Zombie, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'b':SDL_apply_surface(  pSdlJeu->surface_Zombiebas, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'h' :SDL_apply_surface(  pSdlJeu->surface_Zombiehaut, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break ;

                default : SDL_apply_surface(  pSdlJeu->surface_Zombie, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;
            }
            }
            if (getVieZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb))==2)
            {switch (dir)
            {
                case 'd' : SDL_apply_surface(  pSdlJeu->surface_Zombie2droite, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'g': SDL_apply_surface(  pSdlJeu->surface_Zombie2, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'b':SDL_apply_surface(  pSdlJeu->surface_Zombie2bas, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'h' :SDL_apply_surface(  pSdlJeu->surface_Zombie2haut, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break ;

                default : SDL_apply_surface(  pSdlJeu->surface_Zombie2, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;
            }

        }
            if (getVieZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb))==3)
            {
                switch (dir)
            {
                case 'd' : SDL_apply_surface(  pSdlJeu->surface_Zombie3droite, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'g': SDL_apply_surface(  pSdlJeu->surface_Zombie3, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'b':SDL_apply_surface(  pSdlJeu->surface_Zombie3bas, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;

                case 'h' :SDL_apply_surface(  pSdlJeu->surface_Zombie3haut, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break ;

                default : SDL_apply_surface(  pSdlJeu->surface_Zombie3, pSdlJeu->surface_ecran, (getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE, (getCoordYZombie(getElementTabZombie(Jeu->tab_Zomb, i_Zomb)))*TAILLE_SPRITE);
                break;
            }
            }

        }

    for (i_Proj=0; i_Proj<Jeu->nb_Projectile; i_Proj++)
        {

            char dir;
            dir = getDirectionProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj));
            switch (dir)
            {
                case 'h' :SDL_apply_surface(  pSdlJeu->surface_Projectile2, pSdlJeu->surface_ecran, getCoordXProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE, getCoordYProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE);
                break;

                case 'b' :SDL_apply_surface(  pSdlJeu->surface_Projectile2, pSdlJeu->surface_ecran, getCoordXProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE, getCoordYProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE);
                break;

                default : SDL_apply_surface(  pSdlJeu->surface_Projectile, pSdlJeu->surface_ecran, getCoordXProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE, getCoordYProjectile(getElementTabProjectile(Jeu->tab_Proj, i_Proj))*TAILLE_SPRITE);
                break;
            }


        }


    char dir;
    dir = getVuePerso(Pers);
    switch (dir)
    {
        case 'd' :SDL_apply_surface(  pSdlJeu->surface_Persoversdroite, pSdlJeu->surface_ecran, getCoordXPerso(Pers)*TAILLE_SPRITE,  getCoordYPerso(Pers)*TAILLE_SPRITE );
            break;
        case 'g' :SDL_apply_surface(  pSdlJeu->surface_Persoversgauche, pSdlJeu->surface_ecran, getCoordXPerso(Pers)*TAILLE_SPRITE,  getCoordYPerso(Pers)*TAILLE_SPRITE );
            break;
        case 'h' :SDL_apply_surface(  pSdlJeu->surface_Persovershaut, pSdlJeu->surface_ecran, getCoordXPerso(Pers)*TAILLE_SPRITE,  getCoordYPerso(Pers)*TAILLE_SPRITE );
            break;
        case 'b' :SDL_apply_surface(  pSdlJeu->surface_Persoversbas, pSdlJeu->surface_ecran, getCoordXPerso(Pers)*TAILLE_SPRITE,  getCoordYPerso(Pers)*TAILLE_SPRITE );
            break;
        default: SDL_apply_surface(  pSdlJeu->surface_Perso, pSdlJeu->surface_ecran, getCoordXPerso(Pers)*TAILLE_SPRITE,  getCoordYPerso(Pers)*TAILLE_SPRITE );
}
    	if (Jeu->nb_Bonus == 1)
            SDL_apply_surface( pSdlJeu->surface_Bonus, pSdlJeu->surface_ecran, getCoordXBonus(bonus)*TAILLE_SPRITE, getCoordYBonus(bonus)*TAILLE_SPRITE );
    }




void sdljeuBoucle(sdlJeu *pSdlJeu)
{
	SDL_Event event;
	int continue_boucle = 1;
    Jeu *Jeu = &(pSdlJeu->jeu);
    Terrain *Ter = jeuGetTerrainPtr(Jeu);

	Perso *Pers = jeuGetPersoPtr(Jeu);
	int nb_alea; // pour le choix du prochain terrain
	int compteurboucle; // varie de 0 à 4
	compteurboucle = 0;

    /* Horloges (en secondes) */
    float horloge_courante, horloge_precedente;
    float horloge_courante2, horloge_precedente2;
    float horloge_courante3, horloge_precedente3;

    /* Intervalle de temps (en secondes) entre deux évolutions du jeu */
    /* Changer la valeur pour ralentir ou accélérer le déplacement des fantomes */
    float intervalle_horloge = 0.01f;
    float intervalle_horloge2 = 0.1f;
    float intervalle_horloge3 = 0.4f;
    int rafraichissement;

	sdljeuAff(pSdlJeu);
	assert( SDL_Flip( pSdlJeu->surface_ecran )!=-1 );

    /* Récupère l'horloge actuelle et la convertit en secondes */

    /* clock() retourne le nombre de tops horloge depuis le lancement du programme */
    horloge_precedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horloge_precedente2 = (float)clock()/(float)CLOCKS_PER_SEC;
    horloge_precedente3 = (float)clock()/(float)CLOCKS_PER_SEC;

	/* Tant que ce n'est pas la fin ... */
	while ( continue_boucle == 1 )
	{
	    int nb_Zomba = Jeu->nb_Zombie;
                int nb;
                for (nb = 0 ; nb <Jeu->nb_Zombie ; nb++)
                {
                    if ( getVieZombie(getElementTabZombie(Jeu->tab_Zomb, nb)) <= 0)
                    {
                        nb_Zomba=nb_Zomba -1 ;
                        detruireZombie(Jeu->tab_Zomb, nb);
                        Jeu->score = Jeu->score +200;
                    }
                }

                 Jeu->nb_Zombie = nb_Zomba;

                for (nb = 0 ; nb <Jeu->nb_Zombie ; nb++)
                {
                    if ( getCoordXZombie(getElementTabZombie(Jeu->tab_Zomb, nb)) == 0)
                    {

                        detruireZombie(Jeu->tab_Zomb , nb);

                        nb_Zomba=nb_Zomba -1 ;


                    }

                }

                Jeu->nb_Zombie = nb_Zomba;
            if (Jeu->pers->vie_Perso <= 0)
                {
                    sdljeuMenuFin(pSdlJeu);
                }

                if (zoneDeMort (Jeu->pers) == 1)
sdljeuMenuFin(pSdlJeu);

	     /* Récupère l'horloge actuelle et la convertit en secondes */
        horloge_courante = (float)clock()/(float)CLOCKS_PER_SEC;
        horloge_courante2 = (float)clock()/(float)CLOCKS_PER_SEC;
        horloge_courante3 = (float)clock()/(float)CLOCKS_PER_SEC;

        if (horloge_courante2-horloge_precedente2>=intervalle_horloge2)
      {
                    evolutionZombie (Jeu);
                    rafraichissement = 1;
                    horloge_precedente2 = horloge_courante2;

      }

       if (horloge_courante3-horloge_precedente3>=intervalle_horloge3)
      {

                    rafraichissement = 1;
                    horloge_precedente3 = horloge_courante3;
                    char * colonne;
                 colonne = malloc(15*sizeof(char));

                if (compteurboucle == 0)
                {
                    nb_alea = rand() % 4 +1 ;
                }

                switch (nb_alea)
                {

                case 1 : colonne = getcolonne(Jeu->Terrain1, compteurboucle);
                        break;
                case 2 : colonne = getcolonne(Jeu->Terrain2, compteurboucle);
                        break;
                case 3 : colonne = getcolonne(Jeu->Terrain3, compteurboucle);
                        break;
                case 4 : colonne = getcolonne(Jeu->Terrain4, compteurboucle);
                        break;

                }

                persovsZombie(Jeu);
                defilementTerrain (Jeu, colonne);
                compteurboucle = compteurboucle +1;


               persovsZombie(Jeu);
                if (compteurboucle >= 4)
                {
                    compteurboucle=0;
                }
                Jeu->score = Jeu->score + 50;
      }



        /* Si suffisamment de temps s'est écoulé depuis la dernière prise d'horloge */
      if (horloge_courante-horloge_precedente>=intervalle_horloge)
      {
               rafraichissement = 1;
               horloge_precedente = horloge_courante;


        if (Jeu->nb_Zombie <5)
                   {
                      if (((int)horloge_courante*1)% 1== 0)
                       {
                          ajouterElement(Jeu->tab_Zomb);
                          Jeu->nb_Zombie=Jeu->nb_Zombie+1;
                       }
                    }


                if (Jeu->nb_Projectile >= 1)
                {
                    evolutionProjectile(Jeu);
                }




                if (Jeu->nb_Bonus == 0)
                {
                    if (Jeu->score %1000 == 0)
                    {
                        spawnBonus(Jeu);
                    }
                }
                else
                {
                persovsBonus(Jeu);
                }


       }


		/* tant qu'il y a des evenements à traiter : cette boucle n'est pas bloquante */
		while ( SDL_PollEvent( &event ) )
		{
			/* Si l'utilisateur a cliqué sur la croix de fermeture */
			if ( event.type == SDL_QUIT )
				continue_boucle = 0;

			/* Si l'utilisateur a appuyé sur une touche */
		if ( event.type == SDL_KEYDOWN )
		{
				switch ( event.key.keysym.sym )
				{
                case SDLK_UP:
					jeuActionClavier( &(pSdlJeu->jeu), 'h');
					rafraichissement = 1;
					break;
				case SDLK_DOWN:
					jeuActionClavier( &(pSdlJeu->jeu), 'b');
					rafraichissement = 1;
					break;
				case SDLK_LEFT:
					jeuActionClavier( &(pSdlJeu->jeu), 'g');
					rafraichissement = 1;
					break;
				case SDLK_RIGHT:
					jeuActionClavier( &(pSdlJeu->jeu), 'd');

					rafraichissement = 1;
					break;
                    case 32:
               jeuActionClavier( &(pSdlJeu->jeu), 'o');
               rafraichissement = 1;
                  break;
				default: break;
				}
			}

		}

        if (rafraichissement==1)
        {
            /* on affiche le jeu sur le buffer caché */
            sdljeuAff(pSdlJeu);

            /* on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans a boucle) */
            SDL_Flip( pSdlJeu->surface_ecran );
        }
	}
}


void sdljeuLibere( sdlJeu *pSdlJeu)
{
	SDL_FreeSurface( pSdlJeu->surface_Perso );
	SDL_FreeSurface( pSdlJeu->surface_mur );
	SDL_FreeSurface( pSdlJeu->surface_Zombie );

	jeuLibere(&(pSdlJeu->jeu));

	SDL_Quit();
}



SDL_Surface *SDL_load_image(const char* filename )
{
	/* Temporary storage for the image that's loaded */
	SDL_Surface* loadedImage = NULL;

	/* The optimized image that will be used */
	SDL_Surface* optimizedImage = NULL;

	/* Load the image */
	loadedImage = SDL_LoadBMP( filename );

	/* If nothing went wrong in loading the image */
	if ( loadedImage != NULL )
	{
		/* Create an optimized image */
		optimizedImage = SDL_DisplayFormat( loadedImage );

		/* Free the old image */
		SDL_FreeSurface( loadedImage );
	}

	/* Return the optimized image */
	return optimizedImage;
}


void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
	/* Make a temporary rectangle to hold the offsets */
	SDL_Rect offset;

	/* Give the offsets to the rectangle */
	offset.x = x;
	offset.y = y;

	/* Blit the surface */
	SDL_BlitSurface( source, NULL, destination, &offset );
}
